An architecture to integrate IEC 61131-3 systems in an IEC 61499 distributed solution

The IEC 61499 standard has been developed to allow the modeling and design of distributed control systems, providing advanced concepts of software engineering (such as abstraction and encapsulation) to the world of control engineering. The introduction of this standard in already existing control environments poses challenges, since programs written using the widespread IEC 61131-3 programming standard cannot be directly executed in a fully IEC 61499 environment without reengineering effort. In order to solve this problem, this paper presents an architecture to integrate modules of the two standards, allowing the exploitation of the benefits of both. The proposed architecture is based on the coexistence of control software of the two standards. Modules written in one standard interact with some particular interfaces that encapsulate functionalities and information to be exchanged with the other standard. In particular, the architecture permits to utilize available run-times without modification, it allows the reuse of software modules, and it utilizes existing features of the standards. A methodology to integrate IEC 61131-3 modules in an IEC 61499 distributed solution based on such architecture is also developed, and it is described via a case study to prove feasibility and benefits. Experimental results demonstrate that the proposed solution does not add substantial load or delays to the system when compared to an IEC 61131-3 based solution. By acting on task period, it can achieve performances similar to an IEC 61499 solution

Integration of existing IEC 61131-3 systems in an IEC 61499 distributed solution

The IEC 61499 standard allows to model and design new generation control systems, providing innovative concepts of software engineering (such as abstraction, encapsulation, reuse) to the world of control engineering. The industrial reception of the standard, however, is still in an early stage, also because its introduction results in the adoption of a programming paradigm profoundly different than the widespread IEC 61131-3. This paper presents a method for the integration of the two standards, that allows to exploit the benefits of both. The proposed architecture is based on the parallel execution of both environments that interact with each other through some specific interfaces. A test implementation of the architecture is also presented to demonstrate the feasibility of the proposed solution

An inspection system for pharmaceutical glass tubes

Abstract: Syringes, vials and carpules for pharmaceutical products are usually made of borosilicate glass. Such containers are made by glass converting companies starting from single glass tubes. These glass containers can suffer from inclusions, air bubbles, stones, scratches and others issues, that can cause subsequent problems like product contamination with glass particulate or cracks in the glass. In recent years, more than 100 million units of drugs packaged in vials or syringes have been withdrawn from the market. As a consequence pharmaceutical companies are demanding an increased delivery of high quality products to manufacturers of glass containers and therefore of glass tubes. An automatic, vision based, quality inspection system can be devoted to perform such task, but specific process features requires the introduction of ad-hoc solutions: in the production lines tubes significantly vibrate and rotate, and the cylindrical surface of the tube needs to be inspected at 360 degrees. This paper presents the design, the development and the experimental evaluation of a vision system to control the quality of glass tubes, highlighting the specific solutions developed to manage vibrations and rotations, obtaining a 360 degree inspection. The system has been designed and tested in a real facility, and proved effective in identifying defects and impurities in the order of tens of microns

Instrumentation of Concurrent Java Applications for Program Behavior Investigation

Java makes easier the coding phase of concurrent applications and provides friendly mechanisms for the information exchange among threads and different processes. The nature of communication and synchronization mechanisms and the actual parallelism of a distributed environment introduce potential sources of non-deterministic behavior in concurrent applications. In order to investigate on undesired effects related to non-deterministic behaviors, tracing and replay capabilities can be added to the programming environment. Such capabilities are useful for testing, debugging, monitoring and performance evaluation purposes. This paper presents a solution for providing tracing and replay capabilities to Java concurrent applications. Such a solution addresses portability and it is based on the automatic instrumentation of the original source code. Some transformation schemes have been applied to some classes in the standard Java packages in order to make easier and more efficient the automatic instrumentation task. It is shown how the object-oriented structure of Java can be exploited in a deep and efficient way both in the instrumentation and in the tracing and replay phases

PSCR: a coherence protocol for eliminating passive sharing in shared-bus shared-memory multiprocessors

AbstractÐIn high-performance general-purpose workstations and servers, the workload can be typically constituted of both sequential and parallel applications. Shared-bus shared-memory multiprocessor can be used to speed-up the execution of such workload. In this environment, the scheduler takes care of the load balancing by allocating a ready process on the first available processor, thus producing process migration. Process migration and the persistence of private data into different caches produce an undesired sharing, named passive sharing. The copies due to passive sharing produce useless coherence traffic on the bus and coping with such a problem may represent a challenging design problem for these machines. Many protocols use smart solutions to limit the overhead to maintain coherence among shared copies. None of these studies treats passive-sharing directly, although some indirect effect is present while dealing with the other kinds of sharing. Affinity scheduling can alleviate this problem, but this technique does not adapt to all load conditions, especially when the effects of migration are massive. We present a simple coherence protocol that eliminates passive sharing using information from the compiler that is normally available in operating system kernels. We evaluate the performance of this protocol and compare it against other solutions proposed in the literature by means of enhanced trace-driven simulation. We evaluate the complexity in terms of the number of protocol states, additional bus lines, and required software support. Our protocol further limits the coherence-maintaining overhead by using information about access patterns to shared data exhibited in parallel applications. Index TermsÐCache memory, coherence protocol, multiprocessor, performance evaluation.